/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package util;

import java.io.*;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Vector;
import model.Alternativa;
import model.Criterio;
import model.Matriz;

/**
 *
 * @author jorge
 */
public class Calculos {

    protected static Calculos calculos;
    protected static Matriz matriz;
    protected static String[][] matrizResultado;
    protected static ArrayList<Alternativa> alternativas;
    protected static ArrayList<Criterio> criterios;
    protected static ArrayList<Alternativa> dominantes;
    protected static int MetodoParaCriteriosMiniziados;
    public static double[] resultadosPonderacionesFinales;
    public static final String RUTA_INFORMES = "src/informes/";
    public static final String NOMBRE_INFORME_OPTIMOS = "informeOptimos.txt";
    public static final String NOMBRE_INFORME_PRESS = "informePress.txt";
    
    public static final int MAXIMIZAR_INVERSA = 1;
    public static final int RESTAR_PONDERACIONES = 2;
    public static final int NORMALIZAR_MAXIMO = 1;
    public static final int NORMALIZAR_RANGO = 2;
    public static final int NORMALIZAR_SUMA = 3;
    public static final int NORMALIZAR_IESIMO = 4;
    public static DecimalFormat df = new DecimalFormat("#.###");
    public static DecimalFormat df2 = new DecimalFormat("#.##");
    
    private static String informePress = "INFORME TÉCNICA PRESS \n\n";
    /**
     * Gets the instance of this class.
     *
     * @return
     */
    public static Calculos getInstance() {
        if (calculos == null) {
            synchronized (Calculos.class) {
                calculos = new Calculos();
            }
        }
        return calculos;
    }

    public static Matriz getMatriz() {
        return matriz;
    }

    public static void setMatriz(Matriz matriz) {
        Calculos.matriz = matriz;
    }

    public static ArrayList<Alternativa> getAlternativas() {
        return alternativas;
    }

    public static ArrayList<Criterio> getCriterios() {
        return criterios;
    }

    public static void setAlternativas(ArrayList<Alternativa> alternativas) {
        Calculos.alternativas = alternativas;
    }

    public static void setCriterios(ArrayList<Criterio> criterios) {
        Calculos.criterios = criterios;
    }

    public static ArrayList<Alternativa> getDominantes() {
        return dominantes;
    }

    public static void setDominantes(ArrayList<Alternativa> dominantes) {
        Calculos.dominantes = dominantes;
    }

    public static int getMetodoParaCriteriosMiniziados() {
        return MetodoParaCriteriosMiniziados;
    }

    public static void setMetodoParaCriteriosMiniziados(int MetodoParaCriteriosMiniziados) {
        Calculos.MetodoParaCriteriosMiniziados = MetodoParaCriteriosMiniziados;
    }

    public static void optimosDePareto() {
        String informe = "INFORME OPTIMOS DE PARETO \n\n";
        int numeroCriteriosSuperior = 0;
        int numeroCriteriosEquivalente = 0;
        int numeroCriteriosInferior = 0;
        for (int alternativaActual = 0; alternativaActual < alternativas.size(); alternativaActual++) {
            for (int i = alternativaActual + 1; i < alternativas.size(); i++) {
                for (int j = 0; j < criterios.size(); j++) {
                    int criterioAlternativaA = Integer.parseInt(matriz.getMatriz()[alternativaActual][j]);
                    int criterioAlternativaI = Integer.parseInt(matriz.getMatriz()[i][j]);
                    if (criterios.get(j).getOptimizacion().equals(Criterio.MAXIMIZAR)) {
                        if (criterioAlternativaA > criterioAlternativaI) {
                            informe += (alternativas.get(alternativaActual).getNombre() + " domina a " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosSuperior++;
                        } else if (criterioAlternativaA == criterioAlternativaI) {
                            informe += (alternativas.get(alternativaActual).getNombre() + " es equivalente a " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosEquivalente++;
                        } else {
                            informe += (alternativas.get(alternativaActual).getNombre() + " es dominada por " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosInferior++;
                        }
                    } else {
                        if (criterioAlternativaA < criterioAlternativaI) {
                            informe += (alternativas.get(alternativaActual).getNombre() + " domina a " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosSuperior++;
                        } else if (criterioAlternativaA == criterioAlternativaI) {
                            informe += (alternativas.get(alternativaActual).getNombre() + " es equivalente a " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosEquivalente++;
                        } else {
                            informe += (alternativas.get(alternativaActual).getNombre() + " es dominada por " + alternativas.get(i).getNombre()) + " en el criterio " + criterios.get(j).getNombre() + "\n";
                            numeroCriteriosInferior++;
                        }
                    }
                }
                if (numeroCriteriosSuperior + numeroCriteriosEquivalente == criterios.size()) {
                    informe += ("\n" + alternativas.get(alternativaActual).getNombre() + " domina a " + alternativas.get(i).getNombre() + "\n\n");
                    dominantes.remove(alternativas.get(i));
                } else if (numeroCriteriosInferior + numeroCriteriosEquivalente == criterios.size()) {
                    informe += ("\n" + alternativas.get(alternativaActual).getNombre() + " es dominada por " + alternativas.get(i).getNombre() + "\n\n");
                    dominantes.remove(alternativas.get(alternativaActual));
                } else {
                    informe += ("\n" + alternativas.get(alternativaActual).getNombre() + " no domina ni es dominada por " + alternativas.get(i).getNombre() + "\n\n");
                }

                numeroCriteriosSuperior = 0;
                numeroCriteriosEquivalente = 0;
                numeroCriteriosInferior = 0;
            }
        }
        informe += (obtenerMatrizDominancia());
        informe += ("\n\nALTERNATIVAS DOMINANTES: ");
        for (Alternativa dom : dominantes) {
            informe += (dom.getNombre() + " ");
        }
//        metodoEntropia();
        escribirInforme(NOMBRE_INFORME_OPTIMOS, informe);
//        pressPaso2();
    }

    public static String obtenerMatrizDominancia() {
        String informeMatrizDominanciaValores = "\nMATRIZ DE DOMINANCIA \n\n ";
        String informeMatrizDominanciaPorcentajes = "\n\nMATRIZ DE DOMINANCIA PORCENTAJES \n ";
        int criteriosSuperior = 0;
        for (int i = 0; i < alternativas.size(); i++) {
            informeMatrizDominanciaValores += alternativas.get(i).getNombre() + "\t\t";
        }
        for (int alternativaActual = 0; alternativaActual < alternativas.size(); alternativaActual++) {
            informeMatrizDominanciaValores += "\n" + alternativas.get(alternativaActual).getNombre() + "\t\t";
            informeMatrizDominanciaPorcentajes += "\n" + alternativas.get(alternativaActual).getNombre() + "\t\t";
            for (int i = 0; i < alternativas.size(); i++) {
                for (int j = 0; j < criterios.size(); j++) {
                    int criterioAlternativaA = Integer.parseInt(matriz.getMatriz()[alternativaActual][j]);
                    int criterioAlternativaI = Integer.parseInt(matriz.getMatriz()[i][j]);
                    if (i != alternativaActual) {
                        if (criterios.get(j).getOptimizacion().equals(Criterio.MAXIMIZAR)) {
                            if (criterioAlternativaA >= criterioAlternativaI) {
                                criteriosSuperior++;
                            }
                        } else {
                            if (criterioAlternativaA <= criterioAlternativaI) {
                                criteriosSuperior++;
                            }
                        }
                    }
                }
                double porcentaje = (criteriosSuperior * 100) / criterios.size();
                informeMatrizDominanciaValores += criteriosSuperior + "\t\t";
                informeMatrizDominanciaPorcentajes += df.format(porcentaje) + "%\t\t";
                criteriosSuperior = 0;
            }
        }
        informeMatrizDominanciaValores += informeMatrizDominanciaPorcentajes;
        return informeMatrizDominanciaValores;
    }

    public static void metodoEntropia() {
        double sumasCriteriosLog[] = new double[criterios.size()];
        double eJs[] = new double[criterios.size()];
        double dJs[] = new double[criterios.size()];
        double wJs[] = new double[criterios.size()];
        double sumaEJs = 0;

        String[][] matrizNormalizadaFraccionSuma = normalizarFraccionSuma(matriz.getMatriz());

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                Double temporal = Double.parseDouble(matrizNormalizadaFraccionSuma[i][j]) * Math.log10(Double.parseDouble(matrizNormalizadaFraccionSuma[i][j]));
                matrizNormalizadaFraccionSuma[i][j] = temporal.toString();
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                sumasCriteriosLog[i] += Double.parseDouble(matrizNormalizadaFraccionSuma[j][i]);
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            double logBase = Math.log10(alternativas.size());
            dJs[i] = (-1 / logBase) * sumasCriteriosLog[i];
            eJs[i] = 1 - dJs[i];
            sumaEJs += eJs[i];
        }

        for (int i = 0; i < criterios.size(); i++) {
            wJs[i] = eJs[i] / sumaEJs;
            criterios.get(i).setPonderacion(wJs[i]);
        }
    }

    public static void escribirInforme(String nombreArchivo, String informe) {

        File f;
        f = new File(RUTA_INFORMES + nombreArchivo);

//Escritura
        try {
            FileWriter w = new FileWriter(f);
            BufferedWriter bw = new BufferedWriter(w);
            PrintWriter wr = new PrintWriter(bw);
            wr.write(informe);//escribimos en el archivo
//            wr.append(" - y aqui continua"); //concatenamos en el archivo sin borrar lo existente
            //ahora cerramos los flujos de canales de datos, al cerrarlos el archivo quedará guardado con información escrita
            //de no hacerlo no se escribirá nada en el archivo
            wr.close();
            bw.close();
        } catch (IOException e) {
            System.out.println("No se pudo generar el informe: " + e);
        }
    }

    public static String[][] normalizarFraccionSuma(String[][] matriz) {
        String[][] matrizResultado = new String[alternativas.size()][criterios.size()];
        double sumasCriterios[] = new double[criterios.size()];

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                matrizResultado[i][j] = matriz[i][j];
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                sumasCriterios[i] += Double.parseDouble(matrizResultado[j][i]);
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                Double temporal = Double.parseDouble(matrizResultado[j][i]) / sumasCriterios[i];
                matrizResultado[j][i] = temporal.toString();
            }
        }

        return matrizResultado;
    }

    public static String[][] normalizarFraccionMaximo(String[][] matriz) {
        String[][] matrizResultado = new String[alternativas.size()][criterios.size()];

        double maximosCriterios[] = new double[criterios.size()];

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                matrizResultado[i][j] = matriz[i][j];
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            maximosCriterios[i] = Double.NEGATIVE_INFINITY;
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                maximosCriterios[i] = Math.max(maximosCriterios[i], Double.parseDouble(matrizResultado[j][i]));
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                if (MetodoParaCriteriosMiniziados != MAXIMIZAR_INVERSA) {
                    Double temporal = Double.parseDouble(matrizResultado[j][i]) / maximosCriterios[i];
                    matrizResultado[j][i] = temporal.toString();
                }
            }
        }

        return matrizResultado;
    }

    public static String[][] normalizarFraccionRango(String[][] matriz) {
        String[][] matrizResultado = new String[alternativas.size()][criterios.size()];

        double maximosCriterios[] = new double[criterios.size()];
        double minimosCriterios[] = new double[criterios.size()];

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                matrizResultado[i][j] = matriz[i][j];
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            maximosCriterios[i] = Double.NEGATIVE_INFINITY;
            minimosCriterios[i] = Double.POSITIVE_INFINITY;
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                maximosCriterios[i] = Math.max(maximosCriterios[i], Double.parseDouble(matrizResultado[j][i]));
                minimosCriterios[i] = Math.min(minimosCriterios[i], Double.parseDouble(matrizResultado[j][i]));
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                Double temporal = (Double.parseDouble(matrizResultado[j][i]) - minimosCriterios[i]) / (maximosCriterios[i] - minimosCriterios[i]);
                matrizResultado[j][i] = temporal.toString();
            }
        }

        return matrizResultado;
    }

    public static String[][] normalizarFraccionIesimo(String[][] matriz) {
        String[][] matrizResultado = new String[alternativas.size()][criterios.size()];
        double sumaCuadradosCriterios[] = new double[criterios.size()];


        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                matrizResultado[i][j] = matriz[i][j];
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            sumaCuadradosCriterios[i] = 0;
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                sumaCuadradosCriterios[i] = sumaCuadradosCriterios[i] + Math.pow(Double.parseDouble(matrizResultado[j][i]), 2);
            }
        }

        for (int i = 0; i < criterios.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                Double temporal = (Double.parseDouble(matrizResultado[j][i])) / (Math.sqrt(sumaCuadradosCriterios[i]));
                matrizResultado[j][i] = temporal.toString();
            }
        }

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                System.out.print(df.format(Double.parseDouble(matrizResultado[i][j])) + "\t");
            }
            System.out.println("");
        }
        return matrizResultado;
    }

    public static String[][] ponderarResultados(int normalizacion) {

        resultadosPonderacionesFinales = new double[alternativas.size()];
        String[][] matrizResultadosFinales = new String[alternativas.size()][criterios.size()];

        for (int i = 0; i < alternativas.size(); i++) {
            resultadosPonderacionesFinales[i] = 0;
        }
        if (normalizacion == Calculos.NORMALIZAR_MAXIMO) {
            matrizResultadosFinales = normalizarFraccionMaximo(matriz.getMatriz());
        } else if (normalizacion == Calculos.NORMALIZAR_RANGO) {
            matrizResultadosFinales = normalizarFraccionRango(matriz.getMatriz());
        } else if (normalizacion == Calculos.NORMALIZAR_SUMA) {
            matrizResultadosFinales = normalizarFraccionSuma(matriz.getMatriz());
        } else if (normalizacion == Calculos.NORMALIZAR_IESIMO) {
            matrizResultadosFinales = normalizarFraccionIesimo(matriz.getMatriz());
        }

        for (int i = 0; i < alternativas.size(); i++) {           //Multiplicar normalizaciones por las ponderaciones de cada criterio
            for (int j = 0; j < criterios.size(); j++) {
                if (Calculos.MetodoParaCriteriosMiniziados == MAXIMIZAR_INVERSA) {
                    if (!criterios.get(j).getOptimizacion().equals(Criterio.MINIMIZAR)) {
                        Double temporal = Double.parseDouble(matrizResultadosFinales[i][j]) * criterios.get(j).getPonderacion();
                        matrizResultadosFinales[i][j] = temporal.toString();
                    }
                } else {
                    Double temporal = Double.parseDouble(matrizResultadosFinales[i][j]) * criterios.get(j).getPonderacion();
                    matrizResultadosFinales[i][j] = temporal.toString();
                }
            }
        }

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                if (Calculos.MetodoParaCriteriosMiniziados == MAXIMIZAR_INVERSA) {
                    resultadosPonderacionesFinales[i] += Double.parseDouble(matrizResultadosFinales[i][j]);
                } else if (Calculos.MetodoParaCriteriosMiniziados == RESTAR_PONDERACIONES) {
                    if (criterios.get(j).getOptimizacion().equals(Criterio.MINIMIZAR)) {
                        resultadosPonderacionesFinales[i] -= Double.parseDouble(matrizResultadosFinales[i][j]);
                    } else {
                        resultadosPonderacionesFinales[i] += Double.parseDouble(matrizResultadosFinales[i][j]);
                    }
                }
            }
        }

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < criterios.size(); j++) {
                System.out.print(matrizResultadosFinales[i][j] + "\t");
            }
            System.out.println("");
        }

        for (int i = 0; i < alternativas.size(); i++) {
            System.out.println(df.format(resultadosPonderacionesFinales[i]) + " ");
        }

        for (int i = 0; i < criterios.size(); i++) {
            System.out.println(df.format(criterios.get(i).getPonderacion()) + " ");
        }

        return matrizResultadosFinales;
     }
    
    public static String [][] pressPaso1(){
        informePress+="- Matriz de valoración: \n\n";
        informePress+="\t\t\t";

        for(int i=0; i<alternativas.size(); i++){
            informePress+=alternativas.get(i).getNombre()+"\t\t";
        }
        
        informePress+="\n";
        
        for(int i=0; i<criterios.size(); i++){
            informePress+=criterios.get(i).getNombre()+" ("+df.format(criterios.get(i).getPonderacion())+")\t\t";
            for(int j=0; j<alternativas.size(); j++){
                informePress+=matriz.getMatriz()[j][i]+"\t\t";
            }
            informePress+="\n";
        }
        
        informePress+="\n";
        informePress+="A partir de este momento para visualizar las tablas de manera adecuada vamos a \n";
        informePress+="usar las siguientes convenciones:\n\n";
        informePress+="- Para las alternativas: \n\n";
        for(int i=0; i<alternativas.size(); i++){
            informePress+="A"+(i+1)+": "+alternativas.get(i).getNombre()+"\n";
        }
        informePress+="\n";
        informePress+="- Para los criterios: \n\n";
        for(int i=0; i<criterios.size(); i++){
            informePress+="C"+(i+1)+": "+criterios.get(i).getNombre()+"\n";
        }
        informePress+="\n";
        return normalizarFraccionMaximo(matriz.getMatriz());
    }

    public static String[][] pressPaso2() {
        int numeroCombinadoAlternativas=(alternativas.size()-1)*alternativas.size();
        String [][] matrizResultado = new String [numeroCombinadoAlternativas] [criterios.size()];
        String [][] matrizNormalizada = pressPaso1();
        int alt1=1;
        int alt2=1;
        informePress+="- Matriz de valoración normalizada: \n\n";
        informePress+="\t\t\t";

        for(int i=0; i<alternativas.size(); i++){
            informePress+="A"+(i+1)+"\t\t";
        }
        
        informePress+="\n";
        
        for(int i=0; i<criterios.size(); i++){
            informePress+="C"+(i+1)+" ("+df.format(criterios.get(i).getPonderacion()) +")\t\t";
            for(int j=0; j<alternativas.size(); j++){
                informePress+=df.format(Double.parseDouble(matrizNormalizada[j][i]))+"\t\t";
            }
            informePress+="\n";
        }
        
        informePress+="\n";
        int tmpA=0;
        for(int i=0; i<alternativas.size(); i++){ 
            for(int j=0; j<alternativas.size(); j++){ 
                if(i!=j){
                    for(int k=0;k<criterios.size();k++){
                        double resultado=0d;
                        if(criterios.get(k).getOptimizacion().equals(Criterio.MAXIMIZAR)){
                            resultado=(Double.parseDouble(matrizNormalizada[i][k])-Double.parseDouble(matrizNormalizada[j][k]))*criterios.get(k).getPonderacion();
                        }else{
                            resultado=(Double.parseDouble(matrizNormalizada[i][k])-Double.parseDouble(matrizNormalizada[j][k]))*-criterios.get(k).getPonderacion();
                        }
                        if (resultado < 0) {
                            resultado = 0d;
                        }
                        matrizResultado[tmpA][k] = String.valueOf(resultado);
                    }
                    tmpA++;
                }
            }
        }
        
        informePress+="- Matriz de dominación: \n\n";
        informePress+="\t\t\t";

        for(int i=0; i<criterios.size(); i++){
            informePress+="C"+(i+1)+"\t\t";
        }
        
        informePress+="Tij\n";
        
        for(int i=0; i<numeroCombinadoAlternativas; i++){  
            double tIJ=0;
            if(alt1==alt2){
                alt2++;
            }            
            informePress+="A"+alt1+" Vs A"+alt2+"*Pk\t\t";
            if(alt2==4){
                alt1++;
                alt2=0;
            }
            alt2++;
            for(int j=0; j<criterios.size(); j++){
                informePress+=df.format(Double.parseDouble(matrizResultado[i][j]))+"\t\t";
                tIJ+=Double.parseDouble(matrizResultado[i][j]);
            }
            informePress+=df.format(tIJ)+"\n";
            tIJ=0;
        }
        
        informePress+="\n";

        return matrizResultado;
    }

    public static String[][] pressPaso3() {
        int numeroAlternativas = (alternativas.size() - 1) * alternativas.size();
        String[][] matrizResultado = new String[alternativas.size()][alternativas.size()];
        String[][] matrizDeDominacion = pressPaso2();
        Vector tIJ = new Vector(numeroAlternativas);
        double tmpTIJ = 0d;
        for (int i = 0; i < numeroAlternativas; i++) {
            for (int j = 0; j < criterios.size(); j++) {
                tmpTIJ += (Double.parseDouble(matrizDeDominacion[i][j]));
            }
            tIJ.add(tmpTIJ);
            tmpTIJ = 0;
        }
        for (int i = alternativas.size() - 1; i >= 0; i--) {
            for (int j = alternativas.size() - 1; j >= 0; j--) {
                if (i == j) {
                    matrizResultado[i][j] = String.valueOf(0d);
                } else {
                    matrizResultado[i][j] = String.valueOf(tIJ.lastElement());
                    tIJ.remove(tIJ.size() - 1);
                }
            }
        }

        informePress+="- Matriz de dominación (Alt Vs Alt): \n\n";
        informePress+="\t\t";

        for(int i=0; i<alternativas.size(); i++){
            informePress+="A"+(i+1)+"\t\t";
        }
        
        informePress+="\n";
        
        for(int i=0; i<alternativas.size(); i++){
            informePress+="A"+(i+1)+"\t\t";
            for(int j=0; j<alternativas.size(); j++){
                informePress+=df.format(Double.parseDouble(matrizResultado[i][j]))+"\t\t";
            }
            informePress+="\n";
        }
        
        informePress+="\n";

        return matrizResultado;
    }

    public static String[][] pressPaso4() {
        String[][] matrizResultado = new String[alternativas.size()][3];
        String[][] matrizDeDominacion2 = pressPaso3();
        Vector ind = new Vector(alternativas.size() * 3);
        double tmpIndH = 0d;
        double tmpIndV = 0d;
        double tmpIndS = 0d;

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                tmpIndH += (Double.parseDouble(matrizDeDominacion2[i][j]));
            }
            ind.add(tmpIndH);
            tmpIndH = 0;
        }

        for (int i = 0; i < alternativas.size(); i++) {
            for (int j = 0; j < alternativas.size(); j++) {
                tmpIndV += (Double.parseDouble(matrizDeDominacion2[j][i]));
            }
            ind.add(tmpIndV);
            tmpIndV = 0;
        }

        for (int i = 0; i < alternativas.size(); i++) {
            tmpIndS = Double.parseDouble(String.valueOf(ind.get(i))) / Double.parseDouble(String.valueOf(ind.get(i + alternativas.size())));
            ind.add(tmpIndS);
            tmpIndS = 0d;
        }
        
        for(int i=0;i<3;i++){
            for(int j=0;j<alternativas.size();j++){
                matrizResultado[j][i]=String.valueOf(ind.get((i*alternativas.size())+j));
            }
        }
         
        informePress+="- Matriz de dominación e indice Press(): \n\n";
        informePress+="\t\tDi\t\tdi\t\tli\n";    
        
        for(int i=0; i<alternativas.size(); i++){
            informePress+="A"+(i+1)+"\t\t";
            for(int j=0; j<3; j++){
                informePress+=df.format(Double.parseDouble(matrizResultado[i][j]))+"\t\t";
            }
            informePress+="\n";
        }
        informePress+="\n";
        
        Vector resultados = new Vector();
        double maxValor=0;
//        matrizResultado[0][2]="2";
//        matrizResultado[1][2]="3";
//        matrizResultado[2][2]="2";
//        matrizResultado[3][2]="3";
        for(int i=0; i<alternativas.size(); i++){
            if(maxValor<Double.parseDouble(matrizResultado[i][2])){
                resultados.clear();
                resultados.add(i);
                maxValor=Double.parseDouble(matrizResultado[i][2]);
            }else if(maxValor==Double.parseDouble(matrizResultado[i][2])){
                resultados.add(i);
            }
        }
        System.out.println(resultados.size());
        if(resultados.size()>1){
            informePress+="Según la técnica Press, las mejores alternativas son:\n";
        }else{
            informePress+="Según la técnica Press, la mejor alternativa es:\n";
        }
        
        for(int i=0; i<resultados.size();i++){
            Integer aux = (Integer)resultados.elementAt(i);
            informePress+="A"+(aux.intValue()+1)+": "+alternativas.get(aux.intValue()).getNombre()+" con un indice Press: "+matrizResultado[aux.intValue()][2]+"\n";
        }
        escribirInforme(NOMBRE_INFORME_PRESS, informePress);
        
        return matrizResultado;
    }
}
